System to generate curated ontologies

ABSTRACT

Example embodiments relate to a network-based ontology curation system employed for receiving a request to view a data object, curating an ontology associated with the data object on-the-fly based on attributes of the request that include device and user characteristics.

PRIORITY APPLICATION

This application is a continuation of, and claims priority to Ser. No.15/659,195, filed Jul. 25, 2017, which is a continuation of, and claimspriority to Ser. No. 15/364,131, filed Nov. 29, 2016, which claimspriority to U.S. Provisional Application Ser. No. 62/404,692, filed Oct.5, 2016, the disclosure of which are incorporated herein in theirentireties by reference.

TECHNICAL FIELD

The present disclosure generally relates to the technical field ofspecial-purpose machines that facilitate the curation and management ofdata sets, including computerized variants of such special-purposemachines and improvements to such variants, and to the technologies bywhich such special-purpose machines become improved compared to otherspecial-purpose machines that facilitate integration of spreadsheetdata. In particular, the present disclosure addresses systems andmethods for the curation, management, and presentation of one or moredata sets into one or more network applications.

BACKGROUND

Computer-based data systems, such as relational database managementsystems, typically organize data sets according to a fixed structure oftables and relationships. The structure may be described using anontology, embodied in a database schema, comprising a data model that isused to represent the structure and reason about objects in thestructure.

An ontology is a fixed data structure that defines a set of tables andrelationships between those tables. Ontologies therefore define a set ofconcepts and relationships that represent the content and structure of adata set embodied as a database schema. Thus, an ontology of a databaseis normally fixed at the time that the database is created; any changeto the ontology represented by the schema is extremely disruptive to thedatabase system, and may require user intervention by an administratorto modify tables or relationships, or to create new tables orrelationships.

However, the volumes of data in high-scale datasets are cumbersome tostore, manage and curate in a structure described using an ontology.High-scale data sets may include sensor data received from one or moresensors. Sensor data is generally presented as a time series, such thateach data point from the sensor includes a timestamp as well as metadatathat may indicate a source of the data point (e.g., an identifier of asensor). Sensor data is generally collected in real-time, over extendedperiods of time. As a result, high-scale data sets may comprise growingvolumes of data that require vast storage space.

The inflexibility of a typical database ontology therefore presents aset of unique technical challenges when attempts are made to curateontologies based on specifications and requirements and whenincorporating high-scale datasets.

BRIEF DESCRIPTION OF THE DRAWINGS

Various ones of the appended drawings merely illustrate exampleembodiments of the present disclosure and are not intended to limit itsscope to the illustrated embodiments. On the contrary, these examplesare intended to cover alternatives, modifications, and equivalents asmay be included within the scope of the disclosure.

FIG. 1 is a network diagram depicting a network system comprising agroup of application servers in communication with a network-basedontology curation system configured for managing and curatinglarge-scale data sets, consistent with some embodiments.

FIG. 2 is a block diagram illustrating various components of theontology curation system, which is provided as part of the networksystem, consistent with some embodiments.

FIG. 3 is a flowchart illustrating a method for curating an ontologybased on a prioritized set of data objects, according to some exampleembodiments.

FIG. 4 is a flowchart illustrating a method for curating an ontologybased on a request to view a data object, according to some exampleembodiments.

FIG. 5 is a flowchart illustrating a method for prioritizing a set ofdata objects according to a machine-learning model, consistent with someembodiments.

FIG. 6 is an interface diagram illustrating presentations of a dataobject based on curated ontologies, consistent with some embodiments.

FIG. 7 is a diagrammatic representation of a machine in the example formof a computer system within which a set of instructions for causing themachine to perform any one or more of the methodologies discussed hereinmay be executed.

DETAILED DESCRIPTION

Reference will now be made in detail to specific example embodiments forcarrying out the inventive subject matter of the present disclosure. Inthe following description, specific details are set forth in order toprovide a thorough understanding of the subject matter. It shall beappreciated that embodiments may be practiced without some or all ofthese specific details.

Example embodiments relate to a network-based ontology curation systememployed for receiving a request to view a data object, curating anontology associated with the data object on-the-fly based on attributesof the request that include device and user characteristics, andgenerating and causing display of a presentation of the data objectbased on the curated ontology. Computer-based database systems, such asrelational database management systems, typically organize dataaccording to a fixed structure of tables and relationships. Thestructure may be described using an ontology, embodied in a databaseschema, comprising a data model that is used to represent the structureand reason about objects in the structure. As discussed above, anontology is normally fixed at the time that the database is created suchthat any change to the ontology represented by the schema is extremelydisruptive to the database system, and may require user intervention byan administrator to modify tables or relationships, or to create newtables or relationships. Thus, a system to curate ontologies may beconfigured to generate the structure and the reasons about the objectsin the structure at the time data is requested.

For example, consider a situation wherein two distinct requesting usersrequest to view the same data object (e.g., the same search terms orreference to the same data object). One of the requesting users may bepart of finance within the organization, while the other requesting useris with engineering. Each requesting user may therefore require anentirely different view of the requested data object—the requesting userfrom finance may primarily be interested in accounting data associatedwith the data object, while the other requesting user may primarily beinterested in project data of projects associated with the data object.

In order to surface and present relevant data to the requesting users,the ontology curation system receives requests to view data objects, andcurates ontologies of linked data associated with the data object of therequest based on attributes of the request itself. In this way, the mostrelevant aspects of the requested data object may be presented torequesting users.

As an example, the request attributes may include a reference to a dataobject, or component of a data object, an identifier of the requestingdevice itself, as well as user attributes of a user making the request(e.g., user profile data). In response to receiving the request, thenetwork-based ontology curation system identifies properties of therequested data object and accesses one or more databases to gather a setof data objects to include in a curated ontology associated with thedata object for the requesting user. The network-based ontology curationsystem retrieves and prioritizes the set of data objects from thedatabase based on the request attributes, and generates a curatedontology based on the prioritization. For example, the system mayprioritize what to show and the placement of the various data objects.Separately, the underlying components for searching and applying anontology may prioritize amongst the various data sources and/or the datafrom a given data source (e.g., for example, if there are duplicates,older or newer entries). In some example embodiments, the network-basedontology curation system generates and causes display of a view of thedata object based on the curated ontology at a graphical user interface(GUI) at the requesting device. A format of the presentation may also bebased on the request attributes.

The database accessed by the ontology curation system to retrieve theset of data objects may include a primary database and a secondarydatabase. In one embodiment, the secondary database includes arelational database that contains foreign keys usable to access dataobjects within the primary database. A foreign key is a field in onetable that uniquely identifies a row of another table. In other words,the foreign key is defined in a second table (e.g., the secondarydatabase) but refers to the primary key in the first table (e.g., theprimary database). For example, a database titled “SENSOR” has a primarykey called “sensor_id.” Another database titled “SENSOR DETAILS” has aforeign key which references “sensor_id” in order to uniquely identifythe relationship between the databases. The ontology curation systemgenerates a curated ontology based on the request attributes of thereceived request. In certain example embodiments, the ontology curationsystem may apply machine learning techniques to curate the ontology.Machine learning is a method used to devise complex models andalgorithms that lend themselves to prediction. For example, the ontologycuration system may index and store requests from various client devicesin order to use the requests as training data to train the ontologycuration system to curate ontologies based on requests. The requests mayinclude requests from client devices for specific types of data fromvarious databases, as well as presentation formats, and priorities ofdata objects. For example, mobile devices associated with anorganization may request a particular set of data objects from thedatabase, whereas desktop devices associated with the organization moreoften request another set of data objects.

In some example embodiments, the ontology curation system may simply beconfigured based on user inputs defining priorities of data objectsbased on request attributes. For example, the ontology curation systemmay receive a configuration specifying priorities, and present formatsof ontologies based on requests attributes. Request attributes mayinclude device identifiers, device attributes of the requesting device(e.g., mobile, desktop, wearable, etc.) organization identifiers, useridentifiers, as well as team identifiers of specific teams withinorganizations (e.g., marketing, security, sales).

FIG. 1 is a network diagram illustrating a network environment 100suitable for operating an ontology curation system 150. A networkedsystem 102 provides server-side functionality, via a network 104 (e.g.,an intranet, the Internet or a Wide Area Network (WAN)), to one or moreclients such as the client device(s) 110 and server 130. In some exampleembodiments, the server 130 may include another client applicationconfigured to run queries against the ontology curation system 150 inorder to generate and utilize curated ontologies. FIG. 1 illustrates aweb client 112 and client application(s) 114 executing on respectiveclient device(s) 110.

An Application Program Interface (API) server 120 and a web server 122are coupled to, and provide programmatic and web interfaces respectivelyto, one or more application server(s) 140. The application servers 140host the ontology curation system 150. The application server(s) 140are, in turn, shown to be coupled to one or more database servers 124that facilitate access to one or more databases 126.

The ontology curation system 150 curates ontologies based on input dataand request attributes from requests received from client devices (e.g.,client device(s) 110). For example, the ontology curation system 150 isconfigured to receive requests to access or view data objects from theclient device(s) 110, access the database(s) 126 to retrieve a set ofdata objects based on request attributes of the request, curate anontology based on the set of data objects, and cause display of apresentation of the curated ontology at the client device(s) 110. Thedatabase(s) 126 may include one or more databases.

As shown, the network environment 100 includes the client device(s) 110in communication with the networked system 102 over the network 104. Thenetworked system 102 communicates and exchanges data with the clientdevice(s) 110 that pertains to various functions and aspects associatedwith the networked system 102 and its users. Likewise, the clientdevice(s) 110, which may be any of a variety of types of devices thatinclude at least a display, a processor, and communication capabilitiesthat provide access to the network 104 (e.g., a smart phone, a tabletcomputer, a personal digital assistant (PDA), a personal navigationdevice (PND), a handheld computer, a desktop computer, a laptop ornetbook, or a wearable computing device), may be operated by a user(e.g., a person) of the networked system 102 to exchange data with thenetworked system 102 over the network 104.

The client device(s) 110 communicates with the network 104 via a wiredor wireless connection. For example, one or more portions of the network104 may comprises an ad hoc network, an intranet, an extranet, a VirtualPrivate Network (VPN), a Local Area Network (LAN), a wireless LAN(WLAN), a Wide Area Network (WAN), a wireless WAN (WWAN), a MetropolitanArea Network (MAN), a portion of the Internet, a portion of the PublicSwitched Telephone Network (PSTN), a cellular telephone network, awireless network, a Wireless Fidelity (Wi-Fi®) network, a WorldwideInteroperability for Microwave Access (WiMax) network, another type ofnetwork, or any suitable combination thereof.

In various embodiments, the data exchanged between the client device(s)110 and the networked system 102 may involve user-selected functionsavailable through one or more user interfaces (UIs). The UIs may bespecifically associated with the web client 112 (e.g., a browser) or theclient application 114, executing on the client device(s) 110, and incommunication with the networked system 102.

FIG. 2 is a block diagram illustrating various components of theontology curation system 150, which is provided as part of the networkedsystem 102, consistent with some embodiments. To avoid obscuring theinventive subject matter with unnecessary detail, various functionalcomponents (e.g., modules and engines) that are not germane to conveyingan understanding of the inventive subject matter have been omitted fromFIG. 2. However, a skilled artisan will readily recognize that variousadditional functional components may be supported by the ontologycuration system 150 to facilitate additional functionality that is notspecifically described herein.

As is understood by skilled artisans in the relevant computer arts, eachfunctional component (e.g., module) illustrated in FIG. 2 may beimplemented using hardware (e.g., a processor of a machine) or acombination of logic (e.g., executable software instructions) andhardware (e.g., memory and processor of a machine) for executing thelogic. Furthermore, the various functional components depicted in FIG. 2may reside on a single computer (e.g., a laptop), or may be distributedacross several computers in various arrangements such as cloud-basedarchitectures. Moreover, any two or more modules of the ontologycuration system 150 may be combined into a single module, or subdividedamong multiple modules. It shall be appreciated that while thefunctional components (e.g., modules) of FIG. 2 are discussed in thesingular sense, in other embodiments, multiple instances of one or moreof the modules may be employed.

The ontology curation system 150 is shown as including a communicationmodule 210, a parsing module 220, a curation module 230, a presentationmodule 240, and an object load service 250, all configured tocommunicate with each other and the database(s) 126 (e.g., via a bus,shared memory, a switch, or application programming interfaces (APIs)).Databases 126 may comprise one or more databases, including, for examplea primary database 260 and a secondary database 270. In some exampleembodiments, the primary database 260 is organized in an ontology, andthe secondary database 270 is organized in a distinct format, that isnot an ontology. In some example embodiments, the secondary database 270may contain high-scale datasets including time series data. In furtherembodiments, primary database 260 and/or secondary database 270 may beone or more key-value data stores.

In some example embodiments, the application server 140 transmitsrequests to the ontology curation system 150, which in turn sends therequest along to the database server 124. The database server 124 maythen query a primary database (e.g., the primary database 260). In suchembodiments, the primary database 260 may employ an ontology schema andreturn search results based on the request received from the databaseserver 124. The search results may for example include data objectsincluding a string (e.g., text string), or JSON data object.

In further embodiments, the ontology curation system 150 may include atranslation layer (e.g., Object Load Service 250) configured tointercept returned queries from the primary database 260 to add type,change a type, or to otherwise vary the returned query based on thecustom ontology. For example, the object load service 250 may beconfigured to enrich the returned search results with data retrievedfrom another data source, such as the secondary database 270, whereinthe secondary database 270 may comprise: high-scale data sets, thatinclude time series data; an IP geocoding service that includes datauseable to enrich data objects (e.g., IP addresses) received from theprimary database 260 with latitude/longitude coordinates; as well as amap tile database that contains map imagery depicting locations ofcoordinates.

In some example embodiments, the primary database 260 returns a dataobject in response to receiving the request from the ontology curationsystem 150, wherein the data object is a JSON data object that containsa primary key. The ontology curation system 150 receives the JSON objectand queries the secondary database 270 using the primary key of the JSONdata object as a query.

The communication module 210 provides functionality to communicate withclient devices (e.g., client device(s) 110) in order to receive requeststo view data objects. The requests may include a reference to a dataobject or a component of a data object, as well as attributes andproperties of the requesting device (client device 110), and therequesting user (e.g., user 106). The communication module 210communicates requests.

Object components of a data object may include object properties, objectmedia, object notes, and object links. The object properties arestructured pieces of information that define behavior andcharacteristics of the data object (e.g., a data type). The object mediainclude binary attachments of data that may include images, text, video,and other specialized forms. The object notes are free text containersof information that provide details about the data object itself. Theobject links define connections of any one data object to one or morelinked data objects. Data objects may also include metadata that definesgeo-coordinates (e.g., to indicate a source location of the dataobject), as well as temporal data (e.g., defining a point in time inwhich the data object was collected). In some example embodiments, thedata objects may further include an Access Control List (ACL), which isa list of Access Control Items (ACIs) Each ACI defines a level ofpermission that a particular user or user group is permitted to the dataobject. An ACL includes a set of these permissions.

The presentation module 240 generates and causes display of apresentation of the data object based on the curated ontology at theclient device(s) 110. The presentation may be generated based on: thetype of data to include in an object view; pre-configured presentationrequirements associated with data types; as well as access credentialsof a requesting user. For example, some users may have greater accessprivileges than other users, such that some data may not be viewable. Insome example embodiments, the presentation of the data object is basedon request attributes that include one or more device properties of therequesting device (e.g., client device(s) 110). For example, thepresentation of the data object may differ based on the requestingdevice being a mobile device versus a desktop device, as both deviceswould receive different curated ontologies.

In some example embodiments, the presentation module 240 also determinesa presentation format of each linked data object in the curated ontologybased on corresponding object components. For example, a first dataobject may include object components indicating that the first dataobject can be displayed in a map image, while a second data objectincludes object components that indicate that the second data objectmust be displayed in a time series. The presentation module 240 formatsthe presentation of the curated ontology based on the object components.

FIG. 2 also includes a depiction of database(s) 126, wherein thedatabase(s) 126 may include a primary database 260 and a secondarydatabase 270. In some example embodiments, the primary database 260 mayreceive data (e.g., high-scale data sets) from a data source. Theparsing module 220 may access the data from the database 260 and parseout data attributes to be stored within the secondary database 270(e.g., identifiers within the data set, and time stamps). In someexample embodiments, the secondary database 270 may be a columnardatabase. The parsing module 220 may further assign a set of foreignkeys to the parsed data of the secondary database 270 such that theforeign keys identify corresponding rows of data within the primarydatabase 260.

FIG. 3 is a flowchart illustrating a method 300 for curating an ontologybased on a prioritized set of data objects, according to some exampleembodiments. The method 300 is embodied in computer-readableinstructions for execution by one or more processors such that theoperations of the method 300 are performed in part or in whole by thenetwork-based ontology curation system 150; accordingly, the method 300is described below by way of example with reference thereto. However, itshall be appreciated that at least some of the operations of the method300 may be deployed on various other hardware configurations, and themethod 300 is not intended to be limited to the network-based ontologycuration system 150.

At operation 310, the communication module 210 receives a request toview or otherwise access a data object from a client device (e.g.,client device(s) 110). The request may include an identifier of a dataobject (e.g., based on a search query, or file name). In one embodiment,the request may comprise request attributes. In another embodiment, therequest attributes may include at least a user identifier or a deviceidentifier of the client device(s) 110. The request may be to access adata object representative of a person. In some example embodiments, therequest does not need to include an identifier at all, and rather, therequest may simply be a search query in which search results from theprimary database may be used to query the secondary database. The systemmay thereby return relevant information from the primary and/orsecondary database. For example, at operation 310, the user 106 may senda request to the ontology curation system 150 for a specific dataobject, or to simple conduct a search based on a search query.

At operation 320, the communication module 210 queries the API server120, the API server 120 queries the database server 124, and thedatabase server queries one or more databases (e.g., the databases 126).In some embodiments, database(s) 126 comprises at least a primarydatabase (e.g., primary database 260) and a secondary database (e.g.,secondary database 270).

For example, in response to the request from the user 106, the ontologycuration system 150 search a secondary database (e.g., among thedatabases 126) to retrieve a set of data objects based on the datasources searches, the use case (of the request), the user profile data,as well as other attribute s discussed herein.

At operation 330, the ontology curation system 150 receives one or moredata objects, as discussed above, from the databases 126. The set ofdata objects retrieved from the database(s) 126 may all be linked orotherwise related to the data object based on data object components(e.g., links). Links in an ontology are used only between objects in theontology model, and the information for the links/objects may be storedwholly within the primary database 260.

At operation 340, the curation module 230 prioritizes the set of dataobjects retrieved from the database(s) 126 based on the requestattributes of the request from the client device(s) 110. The requestattributes include, for example, an identifier of the client device(s)110, properties and characteristics of the client device(s) 110 (e.g.,device type, display type, display resolution, mobile or desktop, etc.),as well as attributes of the user 106 (e.g., based on user profiledata). For example, certain data objects among the set of data objectsmay be prioritized more highly based on the client device(s) 110 being amobile device versus a desktop device. As discussed above, theprioritization may be based on a use case of the data object as well asthe data type. In some example embodiments, client device display sizemay also play a role. In some example embodiments, the set of dataobjects are also prioritized based on user attributes from a userprofile, such as title, occupation, organization role, etc.

At operation 350, the curation module 230 curates an ontology based onthe prioritized set of data objects and the attributes of the requestfrom the client device(s) 110. The curated ontology may thereby bedelivered to the presentation module 240 in order to generate apresentation of the data object based on the curated ontology. Theontology consists of: a list of all object types; a list of all objectproperties; a list of all links between data objects; a list of allallowable property types for a given object type; as well as a list ofall allowable link types for a given object type.

In some example embodiments, a default view of the ontology may beoverwritten by a custom view. One such modeling may be a tree, in whichthere are custom views at each level, and overriding at lower levels(when there is greater specificity as to the circumstances behind therequest). Advantages of such embodiments include starting with a broadbase ontology (e.g., only person data objects) that may be refined basedon specific use cases. For example, different person data objects (e.g.,athletes, mechanics, pilots) or even further refined (for example,airplane pilots, stewards, traffic controller) if dealing with aspecific use case (for example, transportation).

FIG. 4 is a flowchart illustrating a method 400 for curating an ontologybased on a request to view a data object, according to some exampleembodiments. The method 400 is embodied in computer-readableinstructions for execution by one or more processors such that theoperations of the method 400 are performed in part or in whole by thenetwork-based ontology curation system 150; accordingly, the method 400is described below by way of example with reference thereto. However, itshall be appreciated that at least some of the operations of the method400 may be deployed on various other hardware configurations, and themethod 400 is not intended to be limited to the network-based ontologycuration system 150. At operation 410, the communication module 210receives a request to view or otherwise access a data object from aclient device (e.g., client device(s) 110). The request may include anidentifier of a data object (e.g., based on a search query, or filename). In one embodiment, the request may comprise request attributes.In another embodiment, the request attributes may include at least auser identifier or a device identifier of the client device(s) 110. Therequest may be to access a data object representative of a person. Insome example embodiments, the request does not need to include anidentifier at all, and rather, the request may simply be a search queryin which search results from the primary database may be used to querythe secondary database. The system may thereby return relevantinformation from the primary and/or secondary database. For example, atoperation 410, the user 106 may send a request to the ontology curationsystem 150 for a specific data object, or to simple conduct a searchbased on a search query.

At operation 420, the communication module 210 queries the API server120, the API server 120 queries the database server 124, and thedatabase server queries one or more databases (e.g., the databases 126).In some embodiments, database(s) 126 comprises at least a primarydatabase (e.g., primary database 260) and a secondary database (e.g.,secondary database 270).

For example, in response to the request from the user 106, the ontologycuration system 150 search a primary database 260 to retrieve a dataobject or set of data objects based on the request attributes. The dataobject or set of data objects within the primary database 260 maycontain corresponding ontology schema, as well as data attributes suchas identifiers.

At operation 430, the ontology curation system 150 receives the one ormore data objects from the primary database 260, and accesses asecondary database 270 to retrieve related data objects. For example,the secondary database 270 may contain high-scale data including timeseries data. The ontology curation system searches the secondarydatabase 270 and retrieves high-scale data related to the one or moredata objects retrieved from the primary database, based on the dataattributes of the one or more data objects.

At operation 440, the curation module 230 curates an ontology based onthe high-scale data, the set of data objects, the request attributes ofthe request, and the ontology schema of the one or more data objectsfrom the primary database 260. The curated ontology may thereby bedelivered to the presentation module 240 in order to generate apresentation of the data object based on the curated ontology. Theontology consists of: a list of all object types; a list of all objectproperties; a list of all links between data objects; a list of allallowable property types for a given object type; as well as a list ofall allowable link types for a given object type.

FIG. 5 is a flowchart illustrating a method 500 for prioritizing a setof data objects according to a machine-learning model, consistent withsome embodiments. As shown in FIG. 5, one or more operations 510, 520,and 530 may be performed as part (e.g., a precursor task, a subroutine,or a portion) of the method 300, in which the ontology curation system150 curates an ontology based on a prioritized set of data objects,according to some example embodiments.

At operation 510, the ontology curation system 150 trains amachine-learning model based on the request to view a data object andrequest attributes, wherein the request attributes further includeontology configurations. For example, the request may include ontologyconfiguration data to define a prioritization of a set of data objectslinked to a requested data object based on object components of the setof data objects. For example, the prioritization may indicate thatclient devices with a particular set of characteristics (e.g., mobile,desktop client, wearable, etc.) have prioritization requirements thatdefine what types of data objects should be presented. In someembodiments, the prioritization may use artificial intelligencetechniques known to one of ordinary skill in the art, such as a neuralnetwork, deep learning, support vector machines, clustering, and/orBayesian networks.

At operation 520, the ontology curation system 150 receives a secondrequest to view the same data object. The second request includessimilar request attributes (e.g., based on having similar devicecharacteristics and input data), however does not include any ontologyconfigurations.

At operation 530, the curation module 230 curates a set of data objectsin response to the second request based on the machine-learning modeland the request attributes of the second request.

FIG. 6 is an interface diagram illustrating presentations 600 of a dataobject based on curated ontologies, consistent with some embodiments.FIG. 6 includes a data object 602, a first presentation of a data object604 that includes a first curation of data objects 606, and a secondpresentation of the data object 608. The second presentation of the dataobject 608 includes a second curation of data objects 610, 612, 614, and616.

As shown in FIG. 6, the data object 602 represents a person. The dataobject 602 includes object components that may include data properties,media, notes, as well as data links to other data objects within thenetworked system 102. Data object 602 includes an identifier (e.g., “BENRICHARDS”), as well as information which defines a data type, a creationtime of the data object 602, and in some embodiments, a user thatcreated the data object 702 (e.g., user 106). The data object 602 alsoincludes metadata such as geo-coordinates of the data object 602 (e.g.,a location of the user 106 when the user 106 created the data object602), as well as temporal metadata specifying a point in time in whichthe data object 602 was created or corresponds.

In some example embodiments, the data object 602 includes objectcomponents that define data source information of the data object 602,as well as security information associated with the data object 602.Examples of data sources include databases, spreadsheets, textdocuments, and individual users. Security information includespermissions associated with the data object 602. Permissions may defineaccess to the data object 602 itself, as well as individual componentsof the data object 602. For example, the permissions may indicate thatonly some users may see a data source of the data object 602. Thesecurity information associated with the data object 602 may be definedin an access control list associated with the data object 602. Examplesof permission levels of a data object are provided in Table-1 below:

TABLE 1 Permission level Data access level Discovery Users can benotified that the data exists but can't see it. Read Users can find andread the data but can't change it. Write Users can find, read, andchange the data. Owner Users can find, read, change, and adjust thepermissions on the data.

As described above in reference to the method 300, a user may provide arequest to the ontology curation system 150 to access or view the dataobject 602. For example, the request may include a reference to anidentifier of the data object 602 (e.g., “BEN RICHARDS”), or may includea selection of a graphical representation of the data object 602displayed within a GUI displayed at the client device(s) 110. Inresponse to receiving the request, the ontology curation system 150curates an ontology associated with the data object 602 in order togenerate and cause display of a presentation of the data object 602 atthe client device(s) 110.

The ontology curated by the ontology curation system 150 may be based onrequest attributes of the request as well as components of the dataobject 602 itself. As shown in FIG. 6, the first presentation of thedata object 604 includes a first curation of data objects 606. Forexample, the ontology curation system 150 may receive a first requestfrom a first client device from among the client devices 110 to view thedata object 602. In response to receiving the first request from thefirst client device, the ontology curation system 150 curates anontology based on the request attributes that include characteristics ofthe first client device. The first presentation of the data object 604may for example be generated based on user attributes of the user 106(e.g., security clearance information), and the first client devicebeing identified as a mobile device, or due to the first client devicehaving a small display screen.

The ontology curation system 150 may receive a second request to accessthe data object 602 from a second client device from among the clientdevice(s) 110. The ontology curation system 150 curates a secondcuration of data object (e.g., data objects 610, 612, 614, and 616)based on request attributes of the second request that includes devicecharacteristics of the second client device. For example, the ontologycuration system 150 may identify that the second client device is adesktop device.

In some example embodiments, as described in FIG. 3, the ontologycuration system 150 may curate the ontology based on various requestattributes that include work group identifiers of the requesting user(e.g., user 106). For example, the ontology curation system 150 maydetermine that the first request described above is from a first workgroup within an organization (e.g., a secretary), whereas the secondrequest is received from a second work group (e.g., sales).

FIG. 7 is a diagrammatic representation of a machine in the example formof a computer system within which a set of instructions for causing themachine to perform any one or more of the methodologies discussed hereinmay be executed. Specifically, FIG. 7 shows a diagrammaticrepresentation of the machine 700 in the example form of a system,within which instructions 702 (e.g., software, a program, anapplication, an applet, an app, a driver, or other executable code) forcausing the machine 700 to perform any one or more of the methodologiesdiscussed herein may be executed. For example, the instructions 702include executable code that causes the machine 700 to execute themethods 400 and 500. In this way, these instructions 702 transform thegeneral, non-programmed machine into a particular machine programmed tocarry out the described and illustrated functions in the mannerdescribed herein. The machine 700 may operate as a standalone device ormay be coupled (e.g., networked) to other machines.

By way of non-limiting example, the machine 700 may comprise orcorrespond to a television, a computer (e.g., a server computer, aclient computer, a personal computer (PC), a tablet computer, a laptopcomputer, or a netbook), a set-top box (STB), a personal digitalassistant (PDA), an entertainment media system (e.g., an audio/videoreceiver), a cellular telephone, a smart phone, a mobile device, awearable device (e.g., a smart watch), a portable media player, or anymachine capable of outputting audio signals and capable of executing theinstructions 702, sequentially or otherwise, that specify actions to betaken by machine 700. Further, while only a single machine 700 isillustrated, the term “machine” shall also be taken to include acollection of machines 700 that individually or jointly execute theinstructions 702 to perform any one or more of the methodologiesdiscussed herein.

The machine 700 may include processors 704, memory 706, storage unit 708and I/O components 710, which may be configured to communicate with eachother such as via a bus 712. In an example embodiment, the processors704 (e.g., a central processing unit (CPU), a reduced instruction setcomputing (RISC) processor, a complex instruction set computing (CISC)processor, a graphics processing unit (GPU), a digital signal processor(DSP), an application specific integrated circuit (ASIC), aradio-frequency integrated circuit (RFIC), another processor, or anysuitable combination thereof) may include, for example, processor 714and processor 716 that may execute instructions 702. The term“processor” is intended to include multi-core processors that maycomprise two or more independent processors (sometimes referred to as“cores”) that may execute instructions 702 contemporaneously. AlthoughFIG. 7 shows multiple processors 704, the machine 700 may include asingle processor with a single core, a single processor with multiplecores (e.g., a multi-core processor), multiple processors with a singlecore, multiple processors with multiples cores, or any combinationthereof.

The memory 706 (e.g., a main memory or other memory storage) and thestorage unit 708 are both accessible to the processors 704 such as viathe bus 712. The memory 706 and the storage unit 708 store theinstructions 702 embodying any one or more of the methodologies orfunctions described herein. In some embodiments, the database(s) 126resides on the storage unit 708. The instructions 702 may also reside,completely or partially, within the memory 706, within the storage unit708, within at least one of the processors 704 (e.g., within theprocessor's cache memory), or any suitable combination thereof, duringexecution thereof by the machine 700. Accordingly, the memory 706, thestorage unit 708, and the memory of processors 704 are examples ofmachine-readable media.

As used herein, “machine-readable medium” means a device able to storeinstructions and data temporarily or permanently and may include, but isnot be limited to, random-access memory (RAM), read-only memory (ROM),buffer memory, flash memory, optical media, magnetic media, cachememory, other types of storage (e.g., erasable programmable read-onlymemory (EEPROM)), or any suitable combination thereof. The term“machine-readable medium” should be taken to include a single medium ormultiple media (e.g., a centralized or distributed database, orassociated caches and servers) able to store instructions 702. The term“machine-readable medium” shall also be taken to include any medium, orcombination of multiple media, that is capable of storing instructions(e.g., instructions 702) for execution by a machine (e.g., machine 700),such that the instructions, when executed by one or more processors ofthe machine 700 (e.g., processors 704), cause the machine 700 to performany one or more of the methodologies described herein (e.g., methods 400and 500). Accordingly, a “machine-readable medium” refers to a singlestorage apparatus or device, as well as “cloud-based” storage systems orstorage networks that include multiple storage apparatus or devices. Theterm “machine-readable medium” excludes signals per se.

Furthermore, the “machine-readable medium” is non-transitory in that itdoes not embody a propagating signal. However, labeling the tangiblemachine-readable medium as “non-transitory” should not be construed tomean that the medium is incapable of movement—the medium should beconsidered as being transportable from one real-world location toanother. Additionally, since the machine-readable medium is tangible,the medium may be considered to be a machine-readable device.

The I/O components 710 may include a wide variety of components toreceive input, provide output, produce output, transmit information,exchange information, capture measurements, and so on. The specific I/Ocomponents 710 that are included in a particular machine will depend onthe type of machine. For example, portable machines such as mobilephones will likely include a touch input device or other such inputmechanisms, while a headless server machine will likely not include sucha touch input device. It will be appreciated that the I/O components 710may include many other components that are not specifically shown inFIG. 7. The I/O components 710 are grouped according to functionalitymerely for simplifying the following discussion and the grouping is inno way limiting. In various example embodiments, the I/O components 710may include input components 718 and output components 720. The inputcomponents 718 may include alphanumeric input components (e.g., akeyboard, a touch screen configured to receive alphanumeric input, aphoto-optical keyboard, or other alphanumeric input components), pointbased input components (e.g., a mouse, a touchpad, a trackball, ajoystick, a motion sensor, or other pointing instrument), tactile inputcomponents (e.g., a physical button, a touch screen that provideslocation and/or force of touches or touch gestures, or other tactileinput components), audio input components, and the like. The outputcomponents 720 may include visual components (e.g., a display such as aplasma display panel (PDP), a light emitting diode (LED) display, aliquid crystal display (LCD), a projector, or a cathode ray tube (CRT)),acoustic components (e.g., speakers), haptic components (e.g., avibratory motor, resistance mechanisms), other signal generators, and soforth.

Communication may be implemented using a wide variety of technologies.The I/O components 710 may include communication components 722 operableto couple the machine 700 to a network 724 or devices 726 via coupling728 and coupling 730, respectively. For example, the communicationcomponents 722 may include a network interface component or othersuitable device to interface with the network 724. In further examples,communication components 722 may include wired communication components,wireless communication components, cellular communication components,near field communication (NFC) components, Bluetooth® components (e.g.,Bluetooth® Low Energy), Wi-Fi® components, and other communicationcomponents to provide communication via other modalities. The devices726 may be another machine or any of a wide variety of peripheraldevices (e.g., a peripheral device coupled via a Universal Serial Bus(USB)).

Modules, Components and Logic

Certain embodiments are described herein as including logic or a numberof components, modules, or mechanisms. Modules may constitute eithersoftware modules (e.g., code embodied on a machine-readable medium or ina transmission signal) or hardware modules. A hardware module is atangible unit capable of performing certain operations and may beconfigured or arranged in a certain manner. In example embodiments, oneor more computer systems (e.g., a standalone, client, or server computersystem) or one or more hardware modules of a computer system (e.g., aprocessor or a group of processors) may be configured by software (e.g.,an application or application portion) as a hardware module thatoperates to perform certain operations as described herein.

In various embodiments, a hardware module may be implementedmechanically or electronically. For example, a hardware module maycomprise dedicated circuitry or logic that is permanently configured(e.g., as a special-purpose processor, such as a field-programmable gatearray (FPGA) or an application-specific integrated circuit (ASIC)) toperform certain operations. A hardware module may also compriseprogrammable logic or circuitry (e.g., as encompassed within ageneral-purpose processor or other programmable processor) that istemporarily configured by software to perform certain operations. Itwill be appreciated that the decision to implement a hardware modulemechanically, in dedicated and permanently configured circuitry, or intemporarily configured circuitry (e.g., configured by software) may bedriven by cost and time considerations.

Accordingly, the term “hardware module” should be understood toencompass a tangible entity, be that an entity that is physicallyconstructed, permanently configured (e.g., hardwired) or temporarilyconfigured (e.g., programmed) to operate in a certain manner and/or toperform certain operations described herein. Considering embodiments inwhich hardware modules are temporarily configured (e.g., programmed),each of the hardware modules need not be configured or instantiated atany one instance in time. For example, where the hardware modulescomprise a general-purpose processor configured using software, thegeneral-purpose processor may be configured as respective differenthardware modules at different times. Software may accordingly configurea processor, for example, to constitute a particular hardware module atone instance of time and to constitute a different hardware module at adifferent instance of time.

Hardware modules can provide information to, and receive informationfrom, other hardware modules. Accordingly, the described hardwaremodules may be regarded as being communicatively coupled. Where multipleof such hardware modules exist contemporaneously, communications may beachieved through signal transmission (e.g., over appropriate circuitsand buses that connect the hardware modules). In embodiments in whichmultiple hardware modules are configured or instantiated at differenttimes, communications between such hardware modules may be achieved, forexample, through the storage and retrieval of information in memorystructures to which the multiple hardware modules have access. Forexample, one hardware module may perform an operation and store theoutput of that operation in a memory device to which it iscommunicatively coupled. A further hardware module may then, at a latertime, access the memory device to retrieve and process the storedoutput. Hardware modules may also initiate communications with input oroutput devices, and can operate on a resource (e.g., a collection ofinformation).

The various operations of example methods described herein may beperformed, at least partially, by one or more processors that aretemporarily configured (e.g., by software) or permanently configured toperform the relevant operations. Whether temporarily or permanentlyconfigured, such processors may constitute processor-implemented modulesthat operate to perform one or more operations or functions. The modulesreferred to herein may, in some example embodiments, compriseprocessor-implemented modules.

Similarly, the methods described herein may be at least partiallyprocessor-implemented. For example, at least some of the operations of amethod may be performed by one or more processors orprocessor-implemented modules. The performance of certain of theoperations may be distributed among the one or more processors, not onlyresiding within a single machine, but deployed across a number ofmachines. In some example embodiments, the processor or processors maybe located in a single location (e.g., within a home environment, anoffice environment, or a server farm), while in other embodiments theprocessors may be distributed across a number of locations.

The one or more processors may also operate to support performance ofthe relevant operations in a “cloud computing” environment or as a“software as a service” (SaaS). For example, at least some of theoperations may be performed by a group of computers (as examples ofmachines including processors), with these operations being accessiblevia a network (e.g., the Internet) and via one or more appropriateinterfaces (e.g., APIs).

Electronic Apparatus and System

Example embodiments may be implemented in digital electronic circuitry,or in computer hardware, firmware, or software, or in combinations ofthem. Example embodiments may be implemented using a computer programproduct, for example, a computer program tangibly embodied in aninformation carrier, for example, in a machine-readable medium forexecution by, or to control the operation of, data processing apparatus,for example, a programmable processor, a computer, or multiplecomputers.

A computer program can be written in any form of programming language,including compiled or interpreted languages, and it can be deployed inany form, including as a standalone program or as a module, subroutine,or other unit suitable for use in a computing environment. A computerprogram can be deployed to be executed on one computer or on multiplecomputers at one site, or distributed across multiple sites andinterconnected by a communication network.

In example embodiments, operations may be performed by one or moreprogrammable processors executing a computer program to performfunctions by operating on input data and generating output. Methodoperations can also be performed by, and apparatus of exampleembodiments may be implemented as, special purpose logic circuitry(e.g., an FPGA or an ASIC).

The computing system can include clients and servers. A client andserver are generally remote from each other and typically interactthrough a communication network. The relationship of client and serverarises by virtue of computer programs running on the respectivecomputers and having a client-server relationship to each other. Inembodiments deploying a programmable computing system, it will beappreciated that both hardware and software architectures meritconsideration. Specifically, it will be appreciated that the choice ofwhether to implement certain functionality in permanently configuredhardware (e.g., an ASIC), in temporarily configured hardware (e.g., acombination of software and a programmable processor), or in acombination of permanently and temporarily configured hardware may be adesign choice. Below are set out hardware (e.g., machine) and softwarearchitectures that may be deployed, in various example embodiments.

Language

Although the embodiments of the present invention have been describedwith reference to specific example embodiments, it will be evident thatvarious modifications and changes may be made to these embodimentswithout departing from the broader scope of the inventive subjectmatter. Accordingly, the specification and drawings are to be regardedin an illustrative rather than a restrictive sense. The accompanyingdrawings that form a part hereof show, by way of illustration, and notof limitation, specific embodiments in which the subject matter may bepracticed. The embodiments illustrated are described in sufficientdetail to enable those skilled in the art to practice the teachingsdisclosed herein. Other embodiments may be used and derived therefrom,such that structural and logical substitutions and changes may be madewithout departing from the scope of this disclosure. This DetailedDescription, therefore, is not to be taken in a limiting sense, and thescope of various embodiments is defined only by the appended claims,along with the full range of equivalents to which such claims areentitled.

Such embodiments of the inventive subject matter may be referred toherein, individually and/or collectively, by the term “invention” merelyfor convenience and without intending to voluntarily limit the scope ofthis application to any single invention or inventive concept if morethan one is in fact disclosed. Thus, although specific embodiments havebeen illustrated and described herein, it should be appreciated that anyarrangement calculated to achieve the same purpose may be substitutedfor the specific embodiments shown. This disclosure is intended to coverany and all adaptations or variations of various embodiments.Combinations of the above embodiments, and other embodiments notspecifically described herein, will be apparent, to those of skill inthe art, upon reviewing the above description.

All publications, patents, and patent documents referred to in thisdocument are incorporated by reference herein in their entirety, asthough individually incorporated by reference. In the event ofinconsistent usages between this document and those documents soincorporated by reference, the usage in the incorporated referencesshould be considered supplementary to that of this document; forirreconcilable inconsistencies, the usage in this document controls.

In this document, the terms “a” or “an” are used, as is common in patentdocuments, to include one or more than one, independent of any otherinstances or usages of “at least one” or “one or more.” In thisdocument, the term “or” is used to refer to a nonexclusive or, such that“A or B” includes “A but not B,” “B but not A,” and “A and B,” unlessotherwise indicated. In the appended claims, the terms “including” and“in which” are used as the plain-English equivalents of the respectiveterms “comprising” and “wherein.” Also, in the following claims, theterms “including” and “comprising” are open-ended; that is, a system,device, article, or process that includes elements in addition to thoselisted after such a term in a claim are still deemed to fall within thescope of that claim.

1. (canceled)
 2. A system comprising: one or more processors of amachine; and a memory storing instructions that, when executed by theone or more processors, cause the machine to perform operationscomprising: receiving a request to access a data object from a clientdevice, the request to access the data object comprising a set ofrequest attributes; identifying a property of the data object responsiveto receiving the request to access the data object from the clientdevice; accessing a plurality of data objects based on the property ofthe data object; and generating a presentation of the plurality of dataobjects based on the set of request attributes of the request.
 3. Thesystem of claim 2, wherein the request attributes include one or more ofthe list comprising: user attributes of a user of the client device;device attributes of the client device; and an ontology configurationassociated with the request, wherein the ontology configuration definesa prioritization of the plurality of data objects.
 4. The system ofclaim 2, wherein the generating the presentation of the plurality ofdata objects based on the set of request attributes of the request isbased on a machine learned model that correlates the set of requestattributes with an ontology configuration that defines a prioritizationof the plurality of data objects.
 5. The system of claim 2, wherein thegenerating the presentation of the plurality of data objects furthercomprise: determining a format of the presentation of the plurality ofdata objects based on the property of the data objects, the format ofthe presentation defining graphical properties of the plurality of dataobjects; and generating the presentation of the plurality of dataobjects based on the set of request attributes of the request and theformat of the presentation of the plurality of data objects.
 6. Thesystem of claim 2, wherein the presentation of the plurality of dataobjects includes an identification of one or more links between each ofthe plurality of data objects.
 7. The system of claim 2, wherein thepresentation of the plurality of data objects includes an ontologicaltree.
 8. The system of claim 2, wherein the accessing the plurality ofdata objects based on the property of the data object further comprises:accessing a database that comprises a collection of data objects, eachdata object among the collection of data object including associatedpermissions that define access criteria for each data object among thecollection of data objects; and retrieving the plurality of data objectsfrom the collection of data objects based on the associated permissionsand the set of request attributes.
 9. A method comprising: receiving arequest to access a data object from a client device, the request toaccess the data object comprising a set of request attributes;identifying a property of the data object responsive to receiving therequest to access the data object from the client device; accessing aplurality of data objects based on the property of the data object; andgenerating a presentation of the plurality of data objects based on theset of request attributes of the request.
 10. The method of claim 9,wherein the request attributes include one or more of the listcomprising: user attributes of a user of the client device; deviceattributes of the client device; and an ontology configurationassociated with the request, wherein the ontology configuration definesa prioritization of the plurality of data objects.
 11. The method ofclaim 9, wherein the generating the presentation of the plurality ofdata objects based on the set of request attributes of the request isbased on a machine learned model that correlates the set of requestattributes with an ontology configuration that defines a prioritizationof the plurality of data objects.
 12. The method of claim 9, wherein thegenerating the presentation of the plurality of data objects furthercomprise: determining a format of the presentation of the plurality ofdata objects based on the property of the data objects, the format ofthe presentation defining graphical properties of the plurality of dataobjects; and generating the presentation of the plurality of dataobjects based on the set of request attributes of the request and theformat of the presentation of the plurality of data objects.
 13. Themethod of claim 9, wherein the presentation of the plurality of dataobjects includes an identification of one or more links between each ofthe plurality of data objects.
 14. The method of claim 9, wherein thepresentation of the plurality of data objects includes an ontologicaltree.
 15. The method of claim 9, wherein the accessing the plurality ofdata objects based on the property of the data object further comprises:accessing a database that comprises a collection of data objects, eachdata object among the collection of data object including associatedpermissions that define access criteria for each data object among thecollection of data objects; and retrieving the plurality of data objectsfrom the collection of data objects based on the associated permissionsand the set of request attributes.
 16. A non-transitory machine-readablestorage medium comprising instructions that, when executed by one ormore processors of a machine, cause the machine to perform operationscomprising: receiving a request to access a data object from a clientdevice, the request to access the data object comprising a set ofrequest attributes; identifying a property of the data object responsiveto receiving the request to access the data object from the clientdevice; accessing a plurality of data objects based on the property ofthe data object; and generating a presentation of the plurality of dataobjects based on the set of request attributes of the request.
 17. Thenon-transitory machine-readable storage medium of claim 16, wherein therequest attributes include one or more of the list comprising: userattributes of a user of the client device; device attributes of theclient device; and an ontology configuration associated with therequest, wherein the ontology configuration defines a prioritization ofthe plurality of data objects.
 18. The non-transitory machine-readablestorage medium of claim 16, wherein the generating the presentation ofthe plurality of data objects based on the set of request attributes ofthe request is based on a machine learned model that correlates the setof request attributes with an ontology configuration that defines aprioritization of the plurality of data objects.
 19. The non-transitorymachine-readable storage medium of claim 16, wherein the generating thepresentation of the plurality of data objects further comprise:determining a format of the presentation of the plurality of dataobjects based on the property of the data objects, the format of thepresentation defining graphical properties of the plurality of dataobjects; and generating the presentation of the plurality of dataobjects based on the set of request attributes of the request and theformat of the presentation of the plurality of data objects.
 20. Thenon-transitory machine-readable storage medium of claim 16, wherein thepresentation of the plurality of data objects includes an identificationof one or more links between each of the plurality of data objects. 21.The non-transitory machine-readable storage medium of claim 16, whereinthe presentation of the plurality of data objects includes anontological tree.